# -*- coding: utf-8 -*-
###############################################################################
""" This file is a part of the VeRyPy classical vehicle routing problem
heuristic library and provides a set of shared Command Line Interface (CLI)
fuctionality for the classical heuristics."""
###############################################################################

# Written in Python 2.7, but try to maintain Python 3+ compatibility
from __future__ import print_function
from __future__ import division

import sys
from time import time
from os import path
from glob import glob
import logging

from natsort import natsorted

import cvrp_ops
import cvrp_io
from util import objf, sol2routes, is_better_sol
from config import DEBUG_VERBOSITY as DEFAULT_DEBUG_VERBOSITY

def print_problem_information(points, D, d, C, L, service_time, tightness=None, verbosity=0):
    N=len(D)
    print("SIZE:", N)
    if C:
        if verbosity>0 and tightness:
            print("TIGHTNESS:", "%.3f"%tightness)
        print("CAPACITY:", C)
    else:
        tightness = 0
    print("DISTANCE:", L)
    print("SERVICE_TIME:", service_time)
    
    if verbosity>2:
        print("POINTS:", points)
        print("DEMANDS:", d, "\n")
    if verbosity>3:
        print("D:", D)
        
    
def print_solution_statistics(sol, D, D_cost, d, C, L=None, service_time=None,
                              verbosity=-1):
    print("\nSOLUTION:", sol)
    cover_ok,capa_ok,rlen_ok = cvrp_ops.check_solution_feasibility(
                                          sol, D_cost,d,C,L,True)
    
    if verbosity>1:
        print("ALL SERVED:", cover_ok)   
        if C:
            print("IS C FEASIBLE:", capa_ok)
        if L:
            print("IS L FEASIBLE:", rlen_ok)
    else:
        print("FEASIBLE:", cover_ok and capa_ok and rlen_ok)
    print("SOLUTION K:", sol.count(0)-1)
    
    sol_f = None if D is None else objf(sol, D) 
    sol_c = None if D_cost is None else objf(sol, D_cost) 
    if (verbosity>0 and sol_f!=sol_c) or (not sol_c):
        print("SOLUTION COST:",sol_c, "\n")
    if sol_c:
        print("SOLUTION LENGTH:",sol_f)
    
    if verbosity>1:
        routes = sol2routes(sol)
        print("ROUTES:")
        print("No.\tCost\tLength\tLoad\tRoute")
        for i, route in enumerate(routes):
            print(i+1,
                  "%.2f"%objf(route,D_cost), 
                  "%.2f"%objf(route,D),
                  sum( (d[n] for n in route )) if C else "-",
                  route, sep='\t' )
        print("Total",
              "%.2f"%objf(sol,D_cost),
              "%.2f"%objf(sol,D), sep='\t')

def read_and_solve_a_problem(problem_instance_path, with_algorithm_function,
                             minimize_K, best_of_n=1, verbosity=-1,
                             single=False, measure_time=False):
    """ Solve a problem instance with the path in problem_instance_path
    with the agorithm in <with_algorithm_function>.
    
    The <with_algorithm_function> has a signature of:
    init_f(points, D_c, d, C, L, st, wtt, verbosity, single, minimize_K)
    
    Options <verbosity>, <single> and <measure_time> may be used to adjust what
    is printed and if a restricted single iteration search (different meaning 
    for different algorithms) is made."""
    
    pfn = problem_instance_path
    N, points, dd_points, d, D, C, ewt = cvrp_io.read_TSPLIB_CVRP(pfn)
    required_K, L, st = cvrp_io.read_TSBLIB_additional_constraints(pfn)
    
    # model service time with the distance matrix
    D_c = cvrp_ops.D2D_c(D, st) if st else D
        
    if points is None:
        if dd_points is not None:
            points = dd_points
        else:
            points, ewt = cvrp_ops.generate_missing_coordinates(D)

    tightness = None
    if C and required_K:
        tightness = (sum(d)/(C*required_K))
    if verbosity>=0:
        print_problem_information(points, D, d,C,L,st,tightness,verbosity)
    
    best_sol = None
    best_f = float('inf')
    best_K = len(D)
    interrupted = False
    for repeat_n in range(best_of_n):
        
        sol, sol_f, sol_K = None, float('inf'), float('inf')
        start = time()
        try:
            sol = with_algorithm_function(points, D_c, d, C, L, st,
                                          ewt, single, minimize_K)
        except KeyboardInterrupt as e:
            print ("WARNING: Solving was interrupted, returning "+
                   "intermediate solution", file=sys.stderr)
            interrupted = True
            # if interrupted on initial sol gen, return the best of those
            if len(e.args)>0 and type(e.args[0]) is list:
                sol = e.args[0]
        elapsed = time()-start 
        
        if sol:      
            sol = cvrp_ops.normalize_solution(sol)
            sol_f = objf(sol, D_c)
            sol_K = sol.count(0)-1
            if is_better_sol(best_f, best_K, sol_f, sol_K, minimize_K):
                best_sol = sol
                best_f = sol_f
                best_K = sol_K
            if best_of_n>1 and verbosity>=1:
                print("SOLUTION QUALITY %d of %d: %.2f"%
                      (repeat_n+1,best_of_n, objf(best_sol, D_c)))
            if measure_time or verbosity>=1:
                print("SOLVED IN: %.2f s"%elapsed)
                
        if interrupted:
            break
            
    if verbosity>=0 and best_sol:
        n_best_sol = cvrp_ops.normalize_solution(best_sol)
        print_solution_statistics(n_best_sol, D, D_c, d, C, L, st, verbosity=verbosity)
    
    if interrupted:
        raise KeyboardInterrupt()
        
    return best_sol, objf(best_sol, D), objf(best_sol, D_c)

def get_a_problem_file_list(problem_paths):
    files_to_solve = []
    for problem_path in problem_paths:
        if path.isdir(problem_path):
            for in_fn in natsorted(glob(path.join(problem_path, "*.vrp"))):
                files_to_solve.append( in_fn )
            for in_fn in natsorted(glob(path.join(problem_path, "*.tsp"))):
                files_to_solve.append( in_fn )
            for in_fn in natsorted(glob(path.join(problem_path, "*.pickle"))):
                files_to_solve.append( in_fn )
        elif path.isfile(problem_path) and problem_path[-4:].lower()==".txt":
            with open(problem_path, 'r') as vrp_list_file:
                for line in vrp_list_file.readlines():
                    line = line.strip()
                    if path.isfile(line):
                        files_to_solve.append(line)
        elif path.isfile(problem_path) and (problem_path[-4:].lower()==".vrp" or
                                            problem_path[-4:].lower()==".tsp" or
                                            problem_path[-7:].lower()==".pickle"):
            files_to_solve.append( problem_path )
        else:
            print(problem_path, "is not a .vrp file, folder, or text file",
                  file=sys.stderr)
    return files_to_solve

def set_logger_level(level, logfile=None):
    #set the logger verbosity level
    if level>=0:            
        logging.basicConfig(format="%(levelname)s:%(message)s",
                            level=logging.DEBUG-level,
                            stream=sys.stdout)
        for lvl in range(1,10):
            logging.addLevelName(lvl, "DEBUG")

        if logfile is not None:
            fileloghandler = logging.FileHandler(logfile)
            fileloghandler.setLevel(logging.DEBUG-level)
            fileloghandler.setFormatter( logging.Formatter("%(levelname)s:%(message)s") )
            logging.getLogger('').addHandler(fileloghandler)
 
def tsp_cli(tsp_f_name, tsp_f):
    # import here so that the function can be used without these dependencies
    from util import objf
    
    if len(sys.argv)==2 and path.isfile(sys.argv[1]):
        P = cvrp_io.read_TSPLIB_CVRP(sys.argv[1])
        D = P.distance_matrix
        start_t = time()
        tsp_sol, tsp_f = tsp_f(D, range(len(D)))
        elapsed_t = time()-start_t
        print("Solved %s with %s in %.2f s"%(path.basename(sys.argv[1]), 
                                             tsp_f_name, elapsed_t))
        tsp_o = objf(tsp_sol,D)
        print("SOLUTION:", str(tsp_sol))
        print("COST:", tsp_o)  
        assert(tsp_f==tsp_o)
    else:
        print("usage: tsp_solver_%s.py TSPLIB_file.tsp"%tsp_f_name, file=sys.stderr)
         
def cli(init_name, init_desc, init_f):
    ## Simple command line interface
    single = False # ask to run only single iteration of the algorithm
    measure_time = False
    verbosity = DEFAULT_DEBUG_VERBOSITY
    minimize_K = False
    output_logfilepath = None
    best_of_n = 1
    interrupted = False
    
    for i in range(0, len(sys.argv)-1):
        if sys.argv[i]=="-v" and sys.argv[i+1].isdigit():
            verbosity = int(sys.argv[i+1])
        if sys.argv[i]=="-n" and sys.argv[i+1].isdigit():
            best_of_n = int(sys.argv[i+1])
        if sys.argv[i]=="-1":
            single = True
        if sys.argv[i]=="-t":
            measure_time = True
        if sys.argv[i]=="-l":
            output_logfilepath = sys.argv[i+1]       
        if sys.argv[i]=="-b":
            otarget = sys.argv[i+1].lower()
            if otarget=="cost" or otarget=="c":
                minimize_K = False
            elif otarget=="vehicles" or otarget=="k":
                minimize_K = True
            else:
                print("WARNING: Ignoring unknown optimization target %s"%otarget)
                
    if verbosity>=0:  
        set_logger_level(verbosity, logfile=output_logfilepath)
        
    if sys.argv[-1].isdigit():        
        N = int(sys.argv[-1])
        problem_name = "random "+str(N)+" point problem"
        N, points, _, d, D, C,_ = cvrp_io.generate_CVRP(N, 100, 20, 5)
        d = [int(de) for de in d]
        D_c = D
        L,st = None, None
        wtt = "EXACT_2D"
        
        best_sol = None
        best_f = float('inf')
        best_K = len(D)
        for i in range(best_of_n):
            sol, sol_f, sol_K = None, float('inf'), float('inf')
            try:
                sol = init_f(points, D_c, d, C, L, st, wtt, single, minimize_K)
            except KeyboardInterrupt as e:
                print ("WARNING: Solving was interrupted, returning "+
                       "intermediate solution", file=sys.stderr)
                interrupted = True
                # if interrupted on initial sol gen, return the best of those
                if len(e.args)>0 and type(e.args[0]) is list:
                    sol = e.args[0]
            if sol:      
                sol = cvrp_ops.normalize_solution(sol)
                sol_f = objf(sol, D_c)
                sol_K = sol.count(0)-1
                
                if is_better_sol(best_f, best_K, sol_f, sol_K, minimize_K):
                    best_sol = sol
                    best_f = sol_f
                    best_K = sol_K
                    
            if interrupted:
                break
                
        print_solution_statistics(best_sol, D, D_c, d, C, L, st, verbosity=verbosity)
    
    problem_file_list = get_a_problem_file_list([sys.argv[-1]])
    if not problem_file_list or "-h" in sys.argv or "--help" in sys.argv:
        print ("Please give a TSPLIB file to solve with "+\
          init_name+\
          " OR give N (integer) to generate a random problem of N customers."+\
          " OR give a path to a folder with .vrp files."+\
          "\n\nOptions (before the file name):\n"+\
          "  -v <int> to set the verbosity level (default %d)\n"%DEFAULT_DEBUG_VERBOSITY+\
          "  -n <int> run the algorithm this many times and return only the best solution\n"+\
          "  -1 to run only one iteration (if applicable)\n"+\
          "  -t to print elapsed wall time\n"+\
          "  -l <file_path> to store the debug output to a file\n"+\
          "  -b <'cost'|'vehicles'> or <c|K> sets the primary optimization oBjective (default is cost)",
          file=sys.stderr)
    elif problem_file_list:
        for problem_path in problem_file_list:
            problem_name = path.basename(problem_path)
            print("Solve", problem_name ,"with", init_name)
            read_and_solve_a_problem(problem_path, init_f, minimize_K, best_of_n, 
                                     verbosity, single, measure_time)
